import { ExtractionResult, ExtractionTask } from '../types';
import { TranslationExtractor } from '../index';
import { TranslationStore } from '../services/TranslationStore';
import { ClassifierFactory } from '../services/ClassifierInterface';
import { ForexDanaClassifier } from '../services/ForexDanaClassifier';
import * as path from 'path';
import * as fs from 'fs';
import { logger } from '../utils/logger';

/**
 * 翻译处理控制器
 * 协调翻译提取、分类和模块化的整个流程
 */
export class TranslationProcessController {
  private task: ExtractionTask;
  
  constructor(task: ExtractionTask) {
    this.task = task;
    
    // 注册分类器
    if (!ClassifierFactory.getRegisteredTypes().includes('forexdana')) {
      ClassifierFactory.register('forexdana', ForexDanaClassifier);
    }
  }
  
  /**
   * 执行完整的处理流程
   */
  public async processTranslations(): Promise<{
    extractionPath: string;
    moduleTreePath: string;
    moduleReportPath: string;
  }> {
    try {
      // 确保reports目录存在
      const reportsDir = path.resolve(process.cwd(), 'reports');
      if (!fs.existsSync(reportsDir)) {
        logger.info(`创建主报告目录: ${reportsDir}`);
        fs.mkdirSync(reportsDir, { recursive: true });
      }
      
      // 1. 提取翻译
      logger.info('开始提取翻译...');
      const extractionResult = await this.extractTranslations();
      
      // 2. 保存提取结果到项目目录下
      logger.info('保存提取结果到项目目录...');
      const projectExtractionPath = TranslationStore.saveExtractionResult(
        extractionResult, 
        this.task.projectId
      );
      logger.info(`提取结果已保存到: ${projectExtractionPath}`);
      
      // 3. 开始分类翻译，仅在解析完成后执行
      logger.info('开始分类翻译...');
      const classifierType = this.determineClassifierType();
      const classifier = ClassifierFactory.create(classifierType, {
        type: classifierType,
        rules: this.task.analysisConfig?.classifierRules || {}
      });
      
      const classificationResult = classifier.classify(extractionResult.translations);
      
      // 5. 生成模块树（如果分类器支持）
      logger.info('开始生成模块树...');
      if (classifier.transformToModules) {
        const moduleTreeResult = classifier.transformToModules(extractionResult.translations);
        
        // 6. 保存模块树
        logger.info('保存模块树...');
        const moduleTreePath = TranslationStore.saveModuleTree(
          moduleTreeResult.moduleTree,
          {
            transform: moduleTreeResult.transformStatistics,
            reference: moduleTreeResult.referenceStatistics
          },
          this.task.projectId
        );
        logger.info(`模块树已保存到: ${moduleTreePath}`);
        
        // 7. 生成并保存模块化报告
        logger.info('生成模块化报告...');
        const moduleReport = classifier.generateModuleReport 
          ? classifier.generateModuleReport(extractionResult.translations)
          : classifier.generateReport(classificationResult);
        
        const moduleReportPath = TranslationStore.saveModuleReport(
          moduleReport,
          this.task.projectId
        );
        logger.info(`模块化报告已保存到: ${moduleReportPath}`);
        
        return {
          extractionPath: projectExtractionPath,
          moduleTreePath,
          moduleReportPath
        };
      } else {
        // 如果分类器不支持模块化，只保存分类报告
        logger.info('生成分类报告...');
        const report = classifier.generateReport(classificationResult);
        const reportPath = TranslationStore.saveModuleReport(
          report,
          this.task.projectId
        );
        logger.info(`分类报告已保存到: ${reportPath}`);
        
        return {
          extractionPath: projectExtractionPath,
          moduleTreePath: '',
          moduleReportPath: reportPath
        };
      }
    } catch (error) {
      logger.error('翻译处理过程中发生错误:', error instanceof Error ? { message: error.message } : { message: String(error) });
      throw error;
    }
  }
  
  /**
   * 提取翻译
   */
  private async extractTranslations(): Promise<ExtractionResult> {
    try {
      // 初始化翻译提取服务
      const extractor = new TranslationExtractor(this.task);
      logger.info('翻译提取服务初始化完成');
      
      // 创建一个Promise，等待完整的解析过程结束
      return new Promise((resolve, reject) => {
        // 使用事件监听方式等待解析完成
        extractor.on('parseCompleted', (data: { result: ExtractionResult, exportPath: string }) => {
          logger.info('接收到解析完成事件', {
            时间戳: new Date().toISOString(),
            导出路径: data.exportPath,
            翻译键数量: data.result.translations.length
          });
          
          // 添加明确的日志表明解析已完成，将继续进行后续处理
          logger.info('翻译解析已完成，即将进行分类和模块分析', {
            时间戳: new Date().toISOString(),
            翻译键数量: data.result.translations.length,
            处理文件数: data.result.statistics.processedFiles
          });
          
          // 结束提取服务
          extractor.stop().then(() => {
            resolve(data.result);
          }).catch(err => {
            logger.warn('停止服务时发生错误，但解析已完成', {
              错误: err instanceof Error ? err.message : String(err)
            });
            // 即使停止服务时出错，仍然返回解析结果
            resolve(data.result);
          });
        });
        
        // 监听解析错误事件
        extractor.on('parseError', (error) => {
          logger.error('解析过程中发生错误', {
            错误: error instanceof Error ? error.message : String(error)
          });
          
          // 尝试停止服务
          extractor.stop().catch(stopErr => {
            logger.error('停止服务失败', {
              错误: stopErr instanceof Error ? stopErr.message : String(stopErr)
            });
          }).finally(() => {
            reject(error);
          });
        });
        
        // 启动翻译提取服务
        extractor.start().catch(err => {
          logger.error('启动翻译提取服务失败', {
            错误: err instanceof Error ? err.message : String(err)
          });
          reject(err);
        });
      });
    } catch (error) {
      logger.error('翻译提取过程中发生错误', {
        错误: error instanceof Error ? error.message : String(error)
      });
      throw error;
    }
  }
  
  /**
   * 确定使用哪种分类器
   */
  private determineClassifierType(): string {
    // 根据项目ID或配置确定使用哪种分类器
    // 这里简单地根据项目ID判断
    if (this.task.projectId.toLowerCase().includes('forexdana')) {
      return 'forexdana';
    }
    
    // 默认使用ForexDana分类器
    return 'forexdana';
  }
} 